node-sass
Advanced tools
The node-sass npm package is a library that allows you to natively compile .scss files to CSS at incredible speed and automatically via a connect middleware. It provides a binding for Node.js to the Sass engine, which is written in C++ and allows for the translation of SCSS or SASS syntax into standard CSS that browsers can understand.
Compiling SCSS to CSS
This feature allows you to compile .scss files into .css files. The 'render' method takes an options object and a callback function. The options object specifies the input and output paths for the SCSS and CSS files, respectively. The callback is invoked after the compilation process, and you can handle the result or error accordingly.
const sass = require('node-sass');
sass.render({
file: 'path/to/input.scss',
outFile: 'path/to/output.css'
}, function(error, result) { // Node-style callback from v3.0.0 onwards
if(!error){
// No errors during the compilation, write this result on the disk
fs.writeFile('path/to/output.css', result.css, function(err){
if(!err){
//file written on disk
}
});
}
});Watching files or directories
This feature allows you to watch .scss files or directories for changes and automatically recompile them to CSS when a change is detected. The example uses 'chokidar', an external library for watching files, to listen for changes on the specified SCSS file and then uses node-sass to compile the file to CSS.
const sass = require('node-sass');
const chokidar = require('chokidar');
chokidar.watch('path/to/input.scss').on('change', () => {
sass.render({
file: 'path/to/input.scss',
outFile: 'path/to/output.css'
}, function(error, result) {
if (!error) {
fs.writeFile('path/to/output.css', result.css, function(err){
if(!err){
console.log('SCSS file updated.');
}
});
}
});
});Command Line Interface (CLI) usage
node-sass provides a CLI for compiling SCSS files to CSS directly from the command line. In this example, the '--output-style' option is used to specify the CSS output format (compressed in this case), '-o' is used to define the output directory for the compiled CSS, and the last argument is the input directory containing the SCSS files.
node-sass --output-style compressed -o dist/css src/scssThe 'sass' package is the primary implementation of Sass, which is written in Dart. It provides the same core functionality as node-sass but does not rely on a native C++ binding, making it more portable and easier to install across different environments. It is also the package recommended by the Sass team as node-sass has been deprecated.
PostCSS is a tool for transforming CSS with JavaScript plugins. While it is not a direct replacement for node-sass, it can be used with plugins like 'precss' to provide similar SCSS-like syntax and features. PostCSS is highly extensible and can be integrated with a large number of plugins to extend its capabilities beyond what node-sass offers.
Less is a backward-compatible language extension for CSS. It is similar to SCSS in terms of features like variables, mixins, and nesting, but it has its own syntax and compiles to CSS using the Less compiler. While it serves a similar purpose to node-sass, it is a different preprocessor language with its own community and ecosystem.
Stylus is a preprocessor that serves as an alternative to SCSS. It offers a flexible syntax with optional colons, semicolons, and braces, and provides powerful features like variable interpolation and functions. Stylus can be seen as a more expressive, but less widely adopted, alternative to node-sass.
Node-sass is a library that provides binding for Node.js to libsass, the C version of the popular stylesheet preprocessor, Sass.
It allows you to natively compile .scss files to css at incredible speed and automatically via a connect middleware.
Find it on npm: https://npmjs.org/package/node-sass
Follow @nodesass on twitter for release updates: https://twitter.com/nodesass
The libsass library is not currently at feature parity with the 3.2 Ruby Gem that most Sass users will use, and has little-to-no support for 3.3 syntax. While we try our best to maintain feature parity with libsass, we can not enable features that have not been implemented in libsass yet.
If you'd like to see what features are still upcoming in libsass, Jo Liss has written a blog post on the subject.
Please check for issues on the libsass repo (as there is a good chance that it may already be an issue there for it), and otherwise create a new issue there.
If this project is missing an API or command line flag that has been added to libsass, then please open an issue here. We will then look at updating our libsass submodule and create a new release. You can help us create the new release by rebuilding binaries, and then creating a pull request to the node-sass-binaries repo.
npm install node-sass
Some users have reported issues installing on Ubuntu due to node being registered to another package. Follow the official NodeJS docs to install NodeJS so that #!/usr/bin/env node correctly resolved.
Compiling versions 0.9.4 and above on Windows machines requires Visual Studio 2013 WD. If you have multiple VS versions, use npm install with the --msvs_version=2013 flag.
var sass = require('node-sass');
sass.render({
file: scss_filename,
success: callback
[, options..]
});
// OR
var css = sass.renderSync({
data: scss_content
[, options..]
});
The API for using node-sass has changed, so that now there is only one variable - an options hash. Some of these options are optional, and in some circumstances some are mandatory.
file is a String of the path to an scss file for libsass to render. One of this or data options are required, for both render and renderSync.
data is a String containing the scss to be rendered by libsass. One of this or file options are required, for both render and renderSync. It is recommended that you use the includePaths option in conjunction with this, as otherwise libsass may have trouble finding files imported via the @import directive.
success is a Function to be called upon successful rendering of the scss to css. This option is required but only for the render function. If provided to renderSync it will be ignored.
error is a Function to be called upon occurance of an error when rendering the scss to css. This option is optional, and only applies to the render function. If provided to renderSync it will be ignored.
includePaths is an Array of path Strings to look for any @imported files. It is recommended that you use this option if you are using the data option and have any @import directives, as otherwise libsass may not find your depended-on files.
imagePath is a String that represents the public image path. When using the image-url() function in a stylesheet, this path will be prepended to the path you supply. eg. Given an imagePath of /path/to/images, background-image: image-url('image.png') will compile to background-image: url("/path/to/images/image.png")
outputStyle is a String to determine how the final CSS should be rendered. Its value should be one of 'nested' or 'compressed'.
['expanded' and 'compact' are not currently supported by libsass]
precision is a Number that will be used to determine how many digits after the decimal will be allowed. For instance, if you had a decimal number of 1.23456789 and a precision of 5, the result will be 1.23457 in the final CSS.
sourceComments is a String to determine what debug information is included in the output file. Its value should be one of 'none', 'normal', 'map'. The default is 'none'.
The map option will create the source map file in your CSS destination.
[Important: souceComments is only supported when using the file option, and does nothing when using data flag.]
If your sourceComments option is set to map, sourceMap allows setting a new path context for the referenced Sass files.
The source map describes a path from your CSS file location, into the the folder where the Sass files are located. In most occasions this will work out-of-the-box but, in some cases, you may need to set a different output.
stats is an empty Object that will be filled with stats from the compilation:
{
entry: "path/to/entry.scss", // or just "data" if the source was not a file
start: 10000000, // Date.now() before the compilation
end: 10000001, // Date.now() after the compilation
duration: 1, // end - start
includedFiles: [ ... ], // absolute paths to all related scss files
sourceMap: "..." // the source map string or null
}
includedFiles isn't sorted in any meaningful way, it's just a list of all imported scss files including the entry.
Same as render() but writes the CSS and sourceMap (if requested) to the filesystem.
outFile specifies where to save the CSS.
sourceMap specifies that the source map should be saved.
sourceMap === true the source map will be saved to the
standard location of path.basename(options.outFile) + '.map'outFile)
where the source map should be savedvar sass = require('node-sass');
var stats = {};
sass.render({
data: 'body{background:blue; a{color:black;}}',
success: function(css) {
console.log(css);
console.log(stats);
},
error: function(error) {
console.log(error);
},
includePaths: [ 'lib/', 'mod/' ],
outputStyle: 'compressed',
stats: stats
});
// OR
console.log(sass.renderSync({
data: 'body{background:blue; a{color:black;}}',
outputStyle: 'compressed',
stats: stats
}));
console.log(stats);
file and data options are set, node-sass will only attempt to honour the file directive.Listing of community uses of node-sass in build tools and frameworks.
Brunch's official sass plugin uses node-sass by default, and automatically falls back to ruby if use of Compass is detected: https://github.com/brunch/sass-brunch
Recompile .scss files automatically for connect and express based http servers
var server = connect.createServer(
sass.middleware({
src: __dirname
, dest: __dirname + '/public'
, debug: true
, outputStyle: 'compressed'
, prefix: '/prefix'
}),
connect.static('/prefix', __dirname + '/public')
);
Heavily inspired by https://github.com/LearnBoost/stylus
@jking90 wrote a DocPad plugin that compiles .scss files using node-sass: https://github.com/jking90/docpad-plugin-nodesass
@stephenway has created an extension that transpiles Sass to CSS using node-sass with duo.js https://github.com/duojs/sass
@sindresorhus has created a set of grunt tasks based on node-sass: https://github.com/sindresorhus/grunt-sass
@dlmanning has created a gulp sass plugin based on node-sass: https://github.com/dlmanning/gulp-sass
@sintaxi’s Harp web server implicitly compiles .scss files using node-sass: https://github.com/sintaxi/harp
@stevenschobert has created a metalsmith plugin based on node-sass: https://github.com/stevenschobert/metalsmith-sass
@fourseven has created a meteor plugin based on node-sass: https://github.com/fourseven/meteor-scss
@dbashford has created a Mimosa module for sass which includes node-sass: https://github.com/dbashford/mimosa-sass
There is also an example connect app here: https://github.com/andrew/node-sass-example
Node-sass includes pre-compiled binaries for popular platforms, to add a binary for your platform follow these steps:
Check out the project:
git clone --recursive https://github.com/sass/node-sass.git
cd node-sass
git submodule update --init --recursive
npm install
npm install -g node-gyp
node-gyp rebuild
The interface for command-line usage is fairly simplistic at this stage, as seen in the following usage section.
Output will be saved with the same name as input SASS file into the current working directory if it's omitted.
node-sass [options] <input.scss> [<output.css>]
Options:
--output-style CSS output style (nested|expanded|compact|compressed) [default: "nested"]
--source-comments Include debug info in output (none|normal|map) [default: "none"]
--include-path Path to look for @import-ed files [default: cwd]
--help, -h Print usage info
Install runs a series of Mocha tests to see if your machine can use the pre-built libsass which will save some time during install. If any tests fail it will build from source.
If you know the pre-built version will work and do not want to wait for the tests to run you can skip the tests by setting the environment variable SKIP_NODE_SASS_TESTS to true.
SKIP_NODE_SASS_TESTS=true npm install
This module is brought to you and maintained by the following people:
We <3 our contributors! A special thanks to all those who have clocked in some dev time on this project, we really appreciate your hard work. You can find a full list of those people here.
Copyright (c) 2013 Andrew Nesbitt. See LICENSE for details.
FAQs
Wrapper around libsass
The npm package node-sass receives a total of 843,154 weekly downloads. As such, node-sass popularity was classified as popular.
We found that node-sass demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 3 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Node.js will be enforcing stricter semver-major PR policies a month before major releases to enhance stability and ensure reliable release candidates.
Security News
Research
Socket's threat research team has detected five malicious npm packages targeting Roblox developers, deploying malware to steal credentials and personal data.
Security News
vlt introduced its new package manager and a serverless registry this week, innovating in a space where npm has stagnated.